home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1995 August: Tool Chest / Dev.CD Aug 95 TC / Dev.CD Aug 95 TC.toast / Tool Chest / Interfaces / UniversalInterfaces 2.0 / PInterfaces / Lists.p < prev    next >
Encoding:
Text File  |  1995-04-18  |  9.2 KB  |  328 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        Lists.p
  3.  
  4.      Contains:    List Manager Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Package:    Universal Interfaces 2.0 in “MPW Latest” on ETO #17
  8.  
  9.      Copyright:    © 1984-1995 by Apple Computer, Inc.
  10.                  All rights reserved.
  11.  
  12.      Bugs?:        If you find a problem with this file, use the Apple Bug Reporter
  13.                  stack.  Include the file and version information (from above)
  14.                  in the problem description and send to:
  15.                      Internet:    apple.bugs@applelink.apple.com
  16.                      AppleLink:    APPLE.BUGS
  17.  
  18. }
  19.  
  20. {$IFC UNDEFINED UsingIncludes}
  21. {$SETC UsingIncludes := 0}
  22. {$ENDC}
  23.  
  24. {$IFC NOT UsingIncludes}
  25.  UNIT Lists;
  26.  INTERFACE
  27. {$ENDC}
  28.  
  29. {$IFC UNDEFINED __LISTS__}
  30. {$SETC __LISTS__ := 1}
  31.  
  32. {$I+}
  33. {$SETC ListsIncludes := UsingIncludes}
  34. {$SETC UsingIncludes := 1}
  35.  
  36.  
  37. {$IFC UNDEFINED __TYPES__}
  38. {$I Types.p}
  39. {$ENDC}
  40. {    ConditionalMacros.p                                            }
  41.  
  42. {$IFC UNDEFINED __CONTROLS__}
  43. {$I Controls.p}
  44. {$ENDC}
  45. {    Quickdraw.p                                                    }
  46. {        MixedMode.p                                                }
  47. {        QuickdrawText.p                                            }
  48. {    Menus.p                                                        }
  49. {        Memory.p                                                }
  50.  
  51. {$IFC UNDEFINED __MEMORY__}
  52. {$I Memory.p}
  53. {$ENDC}
  54.  
  55. {$PUSH}
  56. {$ALIGN MAC68K}
  57. {$LibExport+}
  58. {$IFC UNDEFINED STRICT_LISTS }
  59. {$SETC STRICT_LISTS := 0}
  60. {$ENDC}
  61. {$IFC NOT STRICT_LISTS }
  62.  
  63. CONST
  64.     lDoVAutoscroll                = 2;
  65.     lDoHAutoscroll                = 1;
  66.     lOnlyOne                    = -128;
  67.     lExtendDrag                    = 64;
  68.     lNoDisjoint                    = 32;
  69.     lNoExtend                    = 16;
  70.     lNoRect                        = 8;
  71.     lUseSense                    = 4;
  72.     lNoNilHilite                = 2;
  73.  
  74. {$ENDC}
  75.  
  76. CONST
  77.     lInitMsg                    = 0;
  78.     lDrawMsg                    = 1;
  79.     lHiliteMsg                    = 2;
  80.     lCloseMsg                    = 3;
  81.  
  82. {$IFC STRICT_LISTS }
  83.     
  84. TYPE
  85.     ListRef = Ptr;
  86.  
  87.     ListHandle = ListRef;
  88.  
  89. {$ELSEC}
  90.     
  91. TYPE
  92.     ListPtr = ^ListRec;
  93.     ListHandle = ^ListPtr;
  94.  
  95.     ListRef = ListHandle;
  96.  
  97. {$ENDC}
  98.     Cell = Point;
  99.  
  100.     ListBounds = Rect;
  101.  
  102.     DataArray = PACKED ARRAY [0..32000] OF CHAR;
  103.  
  104.     DataPtr = ^DataArray;
  105.     DataHandle = ^DataPtr;
  106.  
  107.     ListSearchProcPtr = ProcPtr;  { FUNCTION ListSearch(aPtr: Ptr; bPtr: Ptr; aLen: INTEGER; bLen: INTEGER): INTEGER; }
  108.     {
  109.         ListClickLoopProcPtr uses register based parameters on the 68k and cannot
  110.         be written in or called from a high-level language without the help of
  111.         mixed mode or assembly glue.
  112.  
  113.         In:
  114.          =>                 .?
  115.         Out:
  116.          <= return value    D0.B
  117.     }
  118.     ListClickLoopProcPtr = Register68kProcPtr;  { register FUNCTION ListClickLoop: BOOLEAN; }
  119.     ListSearchUPP = UniversalProcPtr;
  120.     ListClickLoopUPP = UniversalProcPtr;
  121.  
  122. {$IFC NOT STRICT_LISTS }
  123.     ListRec = RECORD
  124.         rView:                    Rect;
  125.         port:                    GrafPtr;
  126.         indent:                    Point;
  127.         cellSize:                Point;
  128.         visible:                ListBounds;
  129.         vScroll:                ControlRef;
  130.         hScroll:                ControlRef;
  131.         selFlags:                SInt8;
  132.         lActive:                BOOLEAN;
  133.         lReserved:                SInt8;
  134.         listFlags:                SInt8;
  135.         clikTime:                LONGINT;
  136.         clikLoc:                Point;
  137.         mouseLoc:                Point;
  138.         lClickLoop:                ListClickLoopUPP;
  139.         lastClick:                Cell;
  140.         refCon:                    LONGINT;
  141.         listDefProc:            Handle;
  142.         userHandle:                Handle;
  143.         dataBounds:                ListBounds;
  144.         cells:                    DataHandle;
  145.         maxIndex:                INTEGER;
  146.         cellArray:                ARRAY [0..0] OF INTEGER;
  147.     END;
  148.  
  149. {$ENDC}
  150.     ListDefProcPtr = ProcPtr;  { PROCEDURE ListDef(lMessage: INTEGER; lSelect: BOOLEAN; VAR lRect: Rect; lCell: Cell; lDataOffset: INTEGER; lDataLen: INTEGER; lHandle: ListRef); }
  151.     ListCellDrawProcPtr = ProcPtr;  { PROCEDURE ListCellDraw(lMessage: INTEGER; lSelect: BOOLEAN; VAR lRect: Rect; lCell: Cell; dataPtr: UNIV Ptr; lDataLen: INTEGER; lHandle: ListRef); }
  152.     ListDefUPP = UniversalProcPtr;
  153.     ListCellDrawUPP = UniversalProcPtr;
  154.  
  155. CONST
  156.     uppListSearchProcInfo = $00002BE0; { FUNCTION (4 byte param, 4 byte param, 2 byte param, 2 byte param): 2 byte result; }
  157.     uppListClickLoopProcInfo = $00000012; { Register FUNCTION : 1 byte in D0; }
  158.     uppListDefProcInfo = $000EBD80; { PROCEDURE (2 byte param, 1 byte param, 4 byte param, 4 byte param, 2 byte param, 2 byte param, 4 byte param); }
  159.     uppListCellDrawProcInfo = $000EFD80; { PROCEDURE (2 byte param, 1 byte param, 4 byte param, 4 byte param, 4 byte param, 2 byte param, 4 byte param); }
  160.  
  161. FUNCTION NewListSearchProc(userRoutine: ListSearchProcPtr): ListSearchUPP;
  162.     {$IFC NOT GENERATINGCFM }
  163.     INLINE $2E9F;
  164.     {$ENDC}
  165.  
  166. FUNCTION NewListClickLoopProc(userRoutine: ListClickLoopProcPtr): ListClickLoopUPP;
  167.     {$IFC NOT GENERATINGCFM }
  168.     INLINE $2E9F;
  169.     {$ENDC}
  170.  
  171. FUNCTION NewListDefProc(userRoutine: ListDefProcPtr): ListDefUPP;
  172.     {$IFC NOT GENERATINGCFM }
  173.     INLINE $2E9F;
  174.     {$ENDC}
  175.  
  176. FUNCTION NewListCellDrawProc(userRoutine: ListCellDrawProcPtr): ListCellDrawUPP;
  177.     {$IFC NOT GENERATINGCFM }
  178.     INLINE $2E9F;
  179.     {$ENDC}
  180.  
  181. FUNCTION CallListSearchProc(aPtr: Ptr; bPtr: Ptr; aLen: INTEGER; bLen: INTEGER; userRoutine: ListSearchUPP): INTEGER;
  182.     {$IFC NOT GENERATINGCFM}
  183.     INLINE $205F, $4E90;
  184.     {$ENDC}
  185.  
  186. FUNCTION CallListClickLoopProc(userRoutine: ListClickLoopUPP): BOOLEAN;
  187.     {$IFC NOT GENERATINGCFM}
  188.     {To be implemented:  Glue to move parameters into registers.}
  189.     {$ENDC}
  190.  
  191. PROCEDURE CallListDefProc(lMessage: INTEGER; lSelect: BOOLEAN; VAR lRect: Rect; lCell: Cell; lDataOffset: INTEGER; lDataLen: INTEGER; lHandle: ListRef; userRoutine: ListDefUPP);
  192.     {$IFC NOT GENERATINGCFM}
  193.     INLINE $205F, $4E90;
  194.     {$ENDC}
  195.  
  196. PROCEDURE CallListCellDrawProc(lMessage: INTEGER; lSelect: BOOLEAN; VAR lRect: Rect; lCell: Cell; dataPtr: UNIV Ptr; lDataLen: INTEGER; lHandle: ListRef; userRoutine: ListCellDrawUPP);
  197.     {$IFC NOT GENERATINGCFM}
  198.     INLINE $205F, $4E90;
  199.     {$ENDC}
  200.  
  201. FUNCTION LNew({CONST}VAR rView: Rect; {CONST}VAR dataBounds: ListBounds; cSize: Point; theProc: INTEGER; theWindow: WindowRef; drawIt: BOOLEAN; hasGrow: BOOLEAN; scrollHoriz: BOOLEAN; scrollVert: BOOLEAN): ListRef;
  202.     {$IFC NOT GENERATINGCFM}
  203.     INLINE $3F3C, $0044, $A9E7;
  204.     {$ENDC}
  205. PROCEDURE LDispose(lHandle: ListRef);
  206.     {$IFC NOT GENERATINGCFM}
  207.     INLINE $3F3C, $0028, $A9E7;
  208.     {$ENDC}
  209. FUNCTION LAddColumn(count: INTEGER; colNum: INTEGER; lHandle: ListRef): INTEGER;
  210.     {$IFC NOT GENERATINGCFM}
  211.     INLINE $3F3C, $0004, $A9E7;
  212.     {$ENDC}
  213. FUNCTION LAddRow(count: INTEGER; rowNum: INTEGER; lHandle: ListRef): INTEGER;
  214.     {$IFC NOT GENERATINGCFM}
  215.     INLINE $3F3C, $0008, $A9E7;
  216.     {$ENDC}
  217. PROCEDURE LDelColumn(count: INTEGER; colNum: INTEGER; lHandle: ListRef);
  218.     {$IFC NOT GENERATINGCFM}
  219.     INLINE $3F3C, $0020, $A9E7;
  220.     {$ENDC}
  221. PROCEDURE LDelRow(count: INTEGER; rowNum: INTEGER; lHandle: ListRef);
  222.     {$IFC NOT GENERATINGCFM}
  223.     INLINE $3F3C, $0024, $A9E7;
  224.     {$ENDC}
  225. FUNCTION LGetSelect(next: BOOLEAN; VAR theCell: Cell; lHandle: ListRef): BOOLEAN;
  226.     {$IFC NOT GENERATINGCFM}
  227.     INLINE $3F3C, $003C, $A9E7;
  228.     {$ENDC}
  229. FUNCTION LLastClick(lHandle: ListRef): Cell;
  230.     {$IFC NOT GENERATINGCFM}
  231.     INLINE $3F3C, $0040, $A9E7;
  232.     {$ENDC}
  233. FUNCTION LNextCell(hNext: BOOLEAN; vNext: BOOLEAN; VAR theCell: Cell; lHandle: ListRef): BOOLEAN;
  234.     {$IFC NOT GENERATINGCFM}
  235.     INLINE $3F3C, $0048, $A9E7;
  236.     {$ENDC}
  237. FUNCTION LSearch(dataPtr: UNIV Ptr; dataLen: INTEGER; searchProc: ListSearchUPP; VAR theCell: Cell; lHandle: ListRef): BOOLEAN;
  238.     {$IFC NOT GENERATINGCFM}
  239.     INLINE $3F3C, $0054, $A9E7;
  240.     {$ENDC}
  241. PROCEDURE LSize(listWidth: INTEGER; listHeight: INTEGER; lHandle: ListRef);
  242.     {$IFC NOT GENERATINGCFM}
  243.     INLINE $3F3C, $0060, $A9E7;
  244.     {$ENDC}
  245. PROCEDURE LSetDrawingMode(drawIt: BOOLEAN; lHandle: ListRef);
  246.     {$IFC NOT GENERATINGCFM}
  247.     INLINE $3F3C, $002C, $A9E7;
  248.     {$ENDC}
  249. PROCEDURE LScroll(dCols: INTEGER; dRows: INTEGER; lHandle: ListRef);
  250.     {$IFC NOT GENERATINGCFM}
  251.     INLINE $3F3C, $0050, $A9E7;
  252.     {$ENDC}
  253. PROCEDURE LAutoScroll(lHandle: ListRef);
  254.     {$IFC NOT GENERATINGCFM}
  255.     INLINE $3F3C, $0010, $A9E7;
  256.     {$ENDC}
  257. PROCEDURE LUpdate(theRgn: RgnHandle; lHandle: ListRef);
  258.     {$IFC NOT GENERATINGCFM}
  259.     INLINE $3F3C, $0064, $A9E7;
  260.     {$ENDC}
  261. PROCEDURE LActivate(act: BOOLEAN; lHandle: ListRef);
  262.     {$IFC NOT GENERATINGCFM}
  263.     INLINE $4267, $A9E7;
  264.     {$ENDC}
  265. PROCEDURE LCellSize(cSize: Point; lHandle: ListRef);
  266.     {$IFC NOT GENERATINGCFM}
  267.     INLINE $3F3C, $0014, $A9E7;
  268.     {$ENDC}
  269. FUNCTION LClick(pt: Point; modifiers: INTEGER; lHandle: ListRef): BOOLEAN;
  270.     {$IFC NOT GENERATINGCFM}
  271.     INLINE $3F3C, $0018, $A9E7;
  272.     {$ENDC}
  273. PROCEDURE LAddToCell(dataPtr: UNIV Ptr; dataLen: INTEGER; theCell: Cell; lHandle: ListRef);
  274.     {$IFC NOT GENERATINGCFM}
  275.     INLINE $3F3C, $000C, $A9E7;
  276.     {$ENDC}
  277. PROCEDURE LClrCell(theCell: Cell; lHandle: ListRef);
  278.     {$IFC NOT GENERATINGCFM}
  279.     INLINE $3F3C, $001C, $A9E7;
  280.     {$ENDC}
  281. PROCEDURE LGetCell(dataPtr: UNIV Ptr; VAR dataLen: INTEGER; theCell: Cell; lHandle: ListRef);
  282.     {$IFC NOT GENERATINGCFM}
  283.     INLINE $3F3C, $0038, $A9E7;
  284.     {$ENDC}
  285. PROCEDURE LRect(VAR cellRect: Rect; theCell: Cell; lHandle: ListRef);
  286.     {$IFC NOT GENERATINGCFM}
  287.     INLINE $3F3C, $004C, $A9E7;
  288.     {$ENDC}
  289. PROCEDURE LSetCell(dataPtr: UNIV Ptr; dataLen: INTEGER; theCell: Cell; lHandle: ListRef);
  290.     {$IFC NOT GENERATINGCFM}
  291.     INLINE $3F3C, $0058, $A9E7;
  292.     {$ENDC}
  293. PROCEDURE LSetSelect(setIt: BOOLEAN; theCell: Cell; lHandle: ListRef);
  294.     {$IFC NOT GENERATINGCFM}
  295.     INLINE $3F3C, $005C, $A9E7;
  296.     {$ENDC}
  297. PROCEDURE LDraw(theCell: Cell; lHandle: ListRef);
  298.     {$IFC NOT GENERATINGCFM}
  299.     INLINE $3F3C, $0030, $A9E7;
  300.     {$ENDC}
  301. {$IFC NOT STRICT_LISTS }
  302. PROCEDURE LGetCellDataLocation(VAR offset: INTEGER; VAR len: INTEGER; theCell: Cell; lHandle: ListRef);
  303.     {$IFC NOT GENERATINGCFM}
  304.     INLINE $3F3C, $0034, $A9E7;
  305.     {$ENDC}
  306. {$ENDC}
  307. {$IFC OLDROUTINENAMES }
  308. PROCEDURE LDoDraw(drawIt: BOOLEAN; lHandle: ListRef);
  309.     {$IFC NOT GENERATINGCFM}
  310.     INLINE $3F3C, $002C, $A9E7;
  311.     {$ENDC}
  312. PROCEDURE LFind(VAR offset: INTEGER; VAR len: INTEGER; theCell: Cell; lHandle: ListRef);
  313.     {$IFC NOT GENERATINGCFM}
  314.     INLINE $3F3C, $0034, $A9E7;
  315.     {$ENDC}
  316. {$ENDC}
  317.  
  318. {$ALIGN RESET}
  319. {$POP}
  320.  
  321. {$SETC UsingIncludes := ListsIncludes}
  322.  
  323. {$ENDC} {__LISTS__}
  324.  
  325. {$IFC NOT UsingIncludes}
  326.  END.
  327. {$ENDC}
  328.